home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / controls / TextArea.as < prev    next >
Text File  |  2014-03-27  |  30KB  |  995 lines
  1. package mx.controls
  2. {
  3.    import flash.accessibility.AccessibilityProperties;
  4.    import flash.display.DisplayObject;
  5.    import flash.events.Event;
  6.    import flash.events.FocusEvent;
  7.    import flash.events.IOErrorEvent;
  8.    import flash.events.MouseEvent;
  9.    import flash.events.TextEvent;
  10.    import flash.system.IME;
  11.    import flash.system.IMEConversionMode;
  12.    import flash.text.StyleSheet;
  13.    import flash.text.TextField;
  14.    import flash.text.TextFieldAutoSize;
  15.    import flash.text.TextFieldType;
  16.    import flash.text.TextLineMetrics;
  17.    import mx.controls.listClasses.BaseListData;
  18.    import mx.controls.listClasses.IDropInListItemRenderer;
  19.    import mx.controls.listClasses.IListItemRenderer;
  20.    import mx.core.EdgeMetrics;
  21.    import mx.core.FlexVersion;
  22.    import mx.core.IDataRenderer;
  23.    import mx.core.IFlexModuleFactory;
  24.    import mx.core.IFontContextComponent;
  25.    import mx.core.IIMESupport;
  26.    import mx.core.IInvalidating;
  27.    import mx.core.IUITextField;
  28.    import mx.core.ScrollControlBase;
  29.    import mx.core.ScrollPolicy;
  30.    import mx.core.UITextField;
  31.    import mx.core.mx_internal;
  32.    import mx.events.FlexEvent;
  33.    import mx.events.ScrollEvent;
  34.    import mx.events.ScrollEventDetail;
  35.    import mx.events.ScrollEventDirection;
  36.    import mx.managers.IFocusManager;
  37.    import mx.managers.IFocusManagerComponent;
  38.    
  39.    use namespace mx_internal;
  40.    
  41.    public class TextArea extends ScrollControlBase implements IDataRenderer, IDropInListItemRenderer, IFocusManagerComponent, IIMESupport, IListItemRenderer, IFontContextComponent
  42.    {
  43.       
  44.       mx_internal static const VERSION:String = "3.0.0.0";
  45.        
  46.       
  47.       private var _text:String = "";
  48.       
  49.       private var _selectable:Boolean = true;
  50.       
  51.       private var _textWidth:Number;
  52.       
  53.       private var _restrict:String = null;
  54.       
  55.       private var htmlTextChanged:Boolean = false;
  56.       
  57.       private var _maxChars:int = 0;
  58.       
  59.       private var enabledChanged:Boolean = false;
  60.       
  61.       private var _condenseWhite:Boolean = false;
  62.       
  63.       private var accessibilityPropertiesChanged:Boolean = false;
  64.       
  65.       private var _hScrollPosition:Number;
  66.       
  67.       private var _textHeight:Number;
  68.       
  69.       private var displayAsPasswordChanged:Boolean = false;
  70.       
  71.       private var prevMode:String = null;
  72.       
  73.       private var selectableChanged:Boolean = false;
  74.       
  75.       private var restrictChanged:Boolean = false;
  76.       
  77.       private var selectionChanged:Boolean = false;
  78.       
  79.       private var maxCharsChanged:Boolean = false;
  80.       
  81.       private var _tabIndex:int = -1;
  82.       
  83.       private var errorCaught:Boolean = false;
  84.       
  85.       private var _selectionBeginIndex:int = 0;
  86.       
  87.       private var wordWrapChanged:Boolean = false;
  88.       
  89.       private var _data:Object;
  90.       
  91.       private var explicitHTMLText:String = null;
  92.       
  93.       private var styleSheetChanged:Boolean = false;
  94.       
  95.       private var tabIndexChanged:Boolean = false;
  96.       
  97.       private var editableChanged:Boolean = false;
  98.       
  99.       private var _editable:Boolean = true;
  100.       
  101.       private var allowScrollEvent:Boolean = true;
  102.       
  103.       private var _imeMode:String = null;
  104.       
  105.       private var condenseWhiteChanged:Boolean = false;
  106.       
  107.       protected var textField:IUITextField;
  108.       
  109.       private var _listData:BaseListData;
  110.       
  111.       private var _displayAsPassword:Boolean = false;
  112.       
  113.       private var _wordWrap:Boolean = true;
  114.       
  115.       private var _styleSheet:StyleSheet;
  116.       
  117.       private var textChanged:Boolean = false;
  118.       
  119.       private var _accessibilityProperties:AccessibilityProperties;
  120.       
  121.       private var _selectionEndIndex:int = 0;
  122.       
  123.       private var _htmlText:String = "";
  124.       
  125.       private var _vScrollPosition:Number;
  126.       
  127.       private var textSet:Boolean;
  128.       
  129.       public function TextArea()
  130.       {
  131.          super();
  132.          tabChildren = true;
  133.          _horizontalScrollPolicy = ScrollPolicy.AUTO;
  134.          _verticalScrollPolicy = ScrollPolicy.AUTO;
  135.       }
  136.       
  137.       public function get imeMode() : String
  138.       {
  139.          return _imeMode;
  140.       }
  141.       
  142.       public function set imeMode(param1:String) : void
  143.       {
  144.          _imeMode = param1;
  145.       }
  146.       
  147.       override protected function focusOutHandler(param1:FocusEvent) : void
  148.       {
  149.          var _loc2_:IFocusManager = focusManager;
  150.          if(_loc2_)
  151.          {
  152.             _loc2_.defaultButtonEnabled = true;
  153.          }
  154.          super.focusOutHandler(param1);
  155.          if(_imeMode != null && _editable)
  156.          {
  157.             if(IME.conversionMode != IMEConversionMode.UNKNOWN && prevMode != IMEConversionMode.UNKNOWN)
  158.             {
  159.                IME.conversionMode = prevMode;
  160.             }
  161.             IME.enabled = false;
  162.          }
  163.          dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
  164.       }
  165.       
  166.       mx_internal function getTextField() : IUITextField
  167.       {
  168.          return textField;
  169.       }
  170.       
  171.       private function textField_textInputHandler(param1:TextEvent) : void
  172.       {
  173.          param1.stopImmediatePropagation();
  174.          var _loc2_:TextEvent = new TextEvent(TextEvent.TEXT_INPUT,false,true);
  175.          _loc2_.text = param1.text;
  176.          dispatchEvent(_loc2_);
  177.          if(_loc2_.isDefaultPrevented())
  178.          {
  179.             param1.preventDefault();
  180.          }
  181.       }
  182.       
  183.       override public function get accessibilityProperties() : AccessibilityProperties
  184.       {
  185.          return _accessibilityProperties;
  186.       }
  187.       
  188.       override protected function createChildren() : void
  189.       {
  190.          super.createChildren();
  191.          createTextField(-1);
  192.       }
  193.       
  194.       private function adjustScrollBars() : void
  195.       {
  196.          var _loc1_:Number = textField.bottomScrollV - textField.scrollV + 1;
  197.          var _loc2_:Number = textField.numLines;
  198.          setScrollBarProperties(textField.width + textField.maxScrollH,textField.width,textField.numLines,_loc1_);
  199.       }
  200.       
  201.       private function textFieldChanged(param1:Boolean, param2:Boolean) : void
  202.       {
  203.          var _loc3_:* = false;
  204.          var _loc4_:* = false;
  205.          if(!param1)
  206.          {
  207.             _loc3_ = _text != textField.text;
  208.             _text = textField.text;
  209.          }
  210.          _loc4_ = _htmlText != textField.htmlText;
  211.          _htmlText = textField.htmlText;
  212.          if(_loc3_)
  213.          {
  214.             dispatchEvent(new Event("textChanged"));
  215.             if(param2)
  216.             {
  217.                dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
  218.             }
  219.          }
  220.          if(_loc4_)
  221.          {
  222.             dispatchEvent(new Event("htmlTextChanged"));
  223.          }
  224.          _textWidth = textField.textWidth;
  225.          _textHeight = textField.textHeight;
  226.       }
  227.       
  228.       private function textField_ioErrorHandler(param1:IOErrorEvent) : void
  229.       {
  230.       }
  231.       
  232.       [NonCommittingChangeEvent("change")]
  233.       [Bindable("textChanged")]
  234.       public function get text() : String
  235.       {
  236.          return _text;
  237.       }
  238.       
  239.       public function get styleSheet() : StyleSheet
  240.       {
  241.          return _styleSheet;
  242.       }
  243.       
  244.       mx_internal function createTextField(param1:int) : void
  245.       {
  246.          if(!textField)
  247.          {
  248.             textField = IUITextField(createInFontContext(UITextField));
  249.             textField.autoSize = TextFieldAutoSize.NONE;
  250.             textField.enabled = enabled;
  251.             textField.ignorePadding = true;
  252.             textField.multiline = true;
  253.             textField.selectable = true;
  254.             textField.styleName = this;
  255.             textField.tabEnabled = true;
  256.             textField.type = TextFieldType.INPUT;
  257.             textField.useRichTextClipboard = true;
  258.             textField.wordWrap = true;
  259.             textField.addEventListener(Event.CHANGE,textField_changeHandler);
  260.             textField.addEventListener(Event.SCROLL,textField_scrollHandler);
  261.             textField.addEventListener(IOErrorEvent.IO_ERROR,textField_ioErrorHandler);
  262.             textField.addEventListener(TextEvent.TEXT_INPUT,textField_textInputHandler);
  263.             textField.addEventListener("textFieldStyleChange",textField_textFieldStyleChangeHandler);
  264.             textField.addEventListener("textFormatChange",textField_textFormatChangeHandler);
  265.             textField.addEventListener("textInsert",textField_textModifiedHandler);
  266.             textField.addEventListener("textReplace",textField_textModifiedHandler);
  267.             if(param1 == -1)
  268.             {
  269.                addChild(DisplayObject(textField));
  270.             }
  271.             else
  272.             {
  273.                addChildAt(DisplayObject(textField),param1);
  274.             }
  275.          }
  276.       }
  277.       
  278.       override public function get tabIndex() : int
  279.       {
  280.          return _tabIndex;
  281.       }
  282.       
  283.       override public function set accessibilityProperties(param1:AccessibilityProperties) : void
  284.       {
  285.          if(param1 == _accessibilityProperties)
  286.          {
  287.             return;
  288.          }
  289.          _accessibilityProperties = param1;
  290.          accessibilityPropertiesChanged = true;
  291.          invalidateProperties();
  292.       }
  293.       
  294.       public function setSelection(param1:int, param2:int) : void
  295.       {
  296.          _selectionBeginIndex = param1;
  297.          _selectionEndIndex = param2;
  298.          selectionChanged = true;
  299.          invalidateProperties();
  300.       }
  301.       
  302.       [Bindable("condenseWhiteChanged")]
  303.       public function get condenseWhite() : Boolean
  304.       {
  305.          return _condenseWhite;
  306.       }
  307.       
  308.       override protected function isOurFocus(param1:DisplayObject) : Boolean
  309.       {
  310.          return param1 == textField || super.isOurFocus(param1);
  311.       }
  312.       
  313.       [Bindable("displayAsPasswordChanged")]
  314.       public function get displayAsPassword() : Boolean
  315.       {
  316.          return _displayAsPassword;
  317.       }
  318.       
  319.       public function get selectionBeginIndex() : int
  320.       {
  321.          return !!textField ? int(textField.selectionBeginIndex) : int(_selectionBeginIndex);
  322.       }
  323.       
  324.       public function get selectable() : Boolean
  325.       {
  326.          return _selectable;
  327.       }
  328.       
  329.       [Bindable("viewChanged")]
  330.       [Bindable("scroll")]
  331.       override public function set verticalScrollPosition(param1:Number) : void
  332.       {
  333.          super.verticalScrollPosition = param1;
  334.          _vScrollPosition = param1;
  335.          if(textField)
  336.          {
  337.             textField.scrollV = param1 + 1;
  338.             textField.background = false;
  339.          }
  340.          else
  341.          {
  342.             invalidateProperties();
  343.          }
  344.       }
  345.       
  346.       public function set text(param1:String) : void
  347.       {
  348.          textSet = true;
  349.          if(!param1)
  350.          {
  351.             param1 = "";
  352.          }
  353.          if(!isHTML && param1 == _text)
  354.          {
  355.             return;
  356.          }
  357.          _text = param1;
  358.          textChanged = true;
  359.          _htmlText = null;
  360.          explicitHTMLText = null;
  361.          invalidateProperties();
  362.          invalidateSize();
  363.          invalidateDisplayList();
  364.          dispatchEvent(new Event("textChanged"));
  365.          dispatchEvent(new FlexEvent(FlexEvent.VALUE_COMMIT));
  366.       }
  367.       
  368.       public function set data(param1:Object) : void
  369.       {
  370.          var _loc2_:* = undefined;
  371.          _data = param1;
  372.          if(_listData)
  373.          {
  374.             _loc2_ = _listData.label;
  375.          }
  376.          else if(_data != null)
  377.          {
  378.             if(_data is String)
  379.             {
  380.                _loc2_ = String(_data);
  381.             }
  382.             else
  383.             {
  384.                _loc2_ = _data.toString();
  385.             }
  386.          }
  387.          if(_loc2_ !== undefined && !textSet)
  388.          {
  389.             text = _loc2_;
  390.             textSet = false;
  391.          }
  392.          dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
  393.       }
  394.       
  395.       public function set styleSheet(param1:StyleSheet) : void
  396.       {
  397.          _styleSheet = param1;
  398.          styleSheetChanged = true;
  399.          htmlTextChanged = true;
  400.          invalidateProperties();
  401.       }
  402.       
  403.       override protected function measure() : void
  404.       {
  405.          super.measure();
  406.          measuredMinWidth = DEFAULT_MEASURED_MIN_WIDTH;
  407.          measuredWidth = DEFAULT_MEASURED_WIDTH;
  408.          measuredMinHeight = measuredHeight = 2 * DEFAULT_MEASURED_MIN_HEIGHT;
  409.       }
  410.       
  411.       public function get fontContext() : IFlexModuleFactory
  412.       {
  413.          return moduleFactory;
  414.       }
  415.       
  416.       public function get selectionEndIndex() : int
  417.       {
  418.          return !!textField ? int(textField.selectionEndIndex) : int(_selectionEndIndex);
  419.       }
  420.       
  421.       [Bindable("editableChanged")]
  422.       public function get editable() : Boolean
  423.       {
  424.          return _editable;
  425.       }
  426.       
  427.       override protected function focusInHandler(param1:FocusEvent) : void
  428.       {
  429.          var message:String = null;
  430.          var event:FocusEvent = param1;
  431.          if(event.target == this)
  432.          {
  433.             systemManager.stage.focus = TextField(textField);
  434.          }
  435.          var fm:IFocusManager = focusManager;
  436.          if(editable && fm)
  437.          {
  438.             fm.showFocusIndicator = true;
  439.          }
  440.          if(fm)
  441.          {
  442.             fm.defaultButtonEnabled = false;
  443.          }
  444.          super.focusInHandler(event);
  445.          if(_imeMode != null && _editable)
  446.          {
  447.             IME.enabled = true;
  448.             prevMode = IME.conversionMode;
  449.             try
  450.             {
  451.                if(!errorCaught && IME.conversionMode != IMEConversionMode.UNKNOWN)
  452.                {
  453.                   IME.conversionMode = _imeMode;
  454.                }
  455.                errorCaught = false;
  456.             }
  457.             catch(e:Error)
  458.             {
  459.                errorCaught = true;
  460.                message = resourceManager.getString("controls","unsupportedMode",[_imeMode]);
  461.                throw new Error(message);
  462.             }
  463.          }
  464.       }
  465.       
  466.       [Bindable("dataChange")]
  467.       public function get listData() : BaseListData
  468.       {
  469.          return _listData;
  470.       }
  471.       
  472.       [Bindable("wordWrapChanged")]
  473.       public function get wordWrap() : Boolean
  474.       {
  475.          return _wordWrap;
  476.       }
  477.       
  478.       override public function set tabIndex(param1:int) : void
  479.       {
  480.          if(param1 == _tabIndex)
  481.          {
  482.             return;
  483.          }
  484.          _tabIndex = param1;
  485.          tabIndexChanged = true;
  486.          invalidateProperties();
  487.       }
  488.       
  489.       [NonCommittingChangeEvent("change")]
  490.       [Bindable("htmlTextChanged")]
  491.       public function get htmlText() : String
  492.       {
  493.          return _htmlText;
  494.       }
  495.       
  496.       override public function set enabled(param1:Boolean) : void
  497.       {
  498.          if(param1 == enabled)
  499.          {
  500.             return;
  501.          }
  502.          super.enabled = param1;
  503.          enabledChanged = true;
  504.          if(verticalScrollBar)
  505.          {
  506.             verticalScrollBar.enabled = param1;
  507.          }
  508.          if(horizontalScrollBar)
  509.          {
  510.             horizontalScrollBar.enabled = param1;
  511.          }
  512.          invalidateProperties();
  513.          if(border && border is IInvalidating)
  514.          {
  515.             IInvalidating(border).invalidateDisplayList();
  516.          }
  517.       }
  518.       
  519.       private function textField_textFieldStyleChangeHandler(param1:Event) : void
  520.       {
  521.          textFieldChanged(true,false);
  522.       }
  523.       
  524.       public function set restrict(param1:String) : void
  525.       {
  526.          if(param1 == _restrict)
  527.          {
  528.             return;
  529.          }
  530.          _restrict = param1;
  531.          restrictChanged = true;
  532.          invalidateProperties();
  533.          dispatchEvent(new Event("restrictChanged"));
  534.       }
  535.       
  536.       override public function get baselinePosition() : Number
  537.       {
  538.          var _loc1_:String = null;
  539.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  540.          {
  541.             _loc1_ = text;
  542.             if(!_loc1_ || _loc1_ == "")
  543.             {
  544.                _loc1_ = " ";
  545.             }
  546.             return viewMetrics.top + measureText(_loc1_).ascent;
  547.          }
  548.          if(!validateBaselinePosition())
  549.          {
  550.             return NaN;
  551.          }
  552.          return textField.y + textField.baselinePosition;
  553.       }
  554.       
  555.       private function textField_changeHandler(param1:Event) : void
  556.       {
  557.          textFieldChanged(false,false);
  558.          adjustScrollBars();
  559.          textChanged = false;
  560.          htmlTextChanged = false;
  561.          param1.stopImmediatePropagation();
  562.          dispatchEvent(new Event(Event.CHANGE));
  563.       }
  564.       
  565.       public function set condenseWhite(param1:Boolean) : void
  566.       {
  567.          if(param1 == _condenseWhite)
  568.          {
  569.             return;
  570.          }
  571.          _condenseWhite = param1;
  572.          condenseWhiteChanged = true;
  573.          if(isHTML)
  574.          {
  575.             htmlTextChanged = true;
  576.          }
  577.          invalidateProperties();
  578.          invalidateSize();
  579.          invalidateDisplayList();
  580.          dispatchEvent(new Event("condenseWhiteChanged"));
  581.       }
  582.       
  583.       public function get textWidth() : Number
  584.       {
  585.          return _textWidth;
  586.       }
  587.       
  588.       public function set displayAsPassword(param1:Boolean) : void
  589.       {
  590.          if(param1 == _displayAsPassword)
  591.          {
  592.             return;
  593.          }
  594.          _displayAsPassword = param1;
  595.          displayAsPasswordChanged = true;
  596.          invalidateProperties();
  597.          invalidateSize();
  598.          invalidateDisplayList();
  599.          dispatchEvent(new Event("displayAsPasswordChanged"));
  600.       }
  601.       
  602.       override public function get horizontalScrollPolicy() : String
  603.       {
  604.          return height <= 40 ? ScrollPolicy.OFF : mx_internal::_horizontalScrollPolicy;
  605.       }
  606.       
  607.       [Bindable("dataChange")]
  608.       public function get data() : Object
  609.       {
  610.          return _data;
  611.       }
  612.       
  613.       override public function get maxVerticalScrollPosition() : Number
  614.       {
  615.          return !!textField ? Number(textField.maxScrollV - 1) : Number(0);
  616.       }
  617.       
  618.       public function set maxChars(param1:int) : void
  619.       {
  620.          if(param1 == _maxChars)
  621.          {
  622.             return;
  623.          }
  624.          _maxChars = param1;
  625.          maxCharsChanged = true;
  626.          invalidateProperties();
  627.          dispatchEvent(new Event("maxCharsChanged"));
  628.       }
  629.       
  630.       public function set selectable(param1:Boolean) : void
  631.       {
  632.          if(param1 == selectable)
  633.          {
  634.             return;
  635.          }
  636.          _selectable = param1;
  637.          selectableChanged = true;
  638.          invalidateProperties();
  639.       }
  640.       
  641.       [Bindable("viewChanged")]
  642.       [Bindable("scroll")]
  643.       override public function set horizontalScrollPosition(param1:Number) : void
  644.       {
  645.          super.horizontalScrollPosition = param1;
  646.          _hScrollPosition = param1;
  647.          if(textField)
  648.          {
  649.             textField.scrollH = param1;
  650.             textField.background = false;
  651.          }
  652.          else
  653.          {
  654.             invalidateProperties();
  655.          }
  656.       }
  657.       
  658.       override public function setFocus() : void
  659.       {
  660.          var _loc1_:int = verticalScrollPosition;
  661.          allowScrollEvent = false;
  662.          textField.setFocus();
  663.          verticalScrollPosition = _loc1_;
  664.          allowScrollEvent = true;
  665.       }
  666.       
  667.       public function set selectionBeginIndex(param1:int) : void
  668.       {
  669.          _selectionBeginIndex = param1;
  670.          selectionChanged = true;
  671.          invalidateProperties();
  672.       }
  673.       
  674.       [Bindable("restrictChanged")]
  675.       public function get restrict() : String
  676.       {
  677.          return _restrict;
  678.       }
  679.       
  680.       override protected function scrollHandler(param1:Event) : void
  681.       {
  682.          if(param1 is ScrollEvent)
  683.          {
  684.             if(!liveScrolling && ScrollEvent(param1).detail == ScrollEventDetail.THUMB_TRACK)
  685.             {
  686.                return;
  687.             }
  688.             super.scrollHandler(param1);
  689.             textField.scrollH = horizontalScrollPosition;
  690.             textField.scrollV = verticalScrollPosition + 1;
  691.             _vScrollPosition = textField.scrollV - 1;
  692.             _hScrollPosition = textField.scrollH;
  693.          }
  694.       }
  695.       
  696.       public function set fontContext(param1:IFlexModuleFactory) : void
  697.       {
  698.          this.moduleFactory = param1;
  699.       }
  700.       
  701.       mx_internal function removeTextField() : void
  702.       {
  703.          if(textField)
  704.          {
  705.             textField.removeEventListener(Event.CHANGE,textField_changeHandler);
  706.             textField.removeEventListener(Event.SCROLL,textField_scrollHandler);
  707.             textField.removeEventListener(IOErrorEvent.IO_ERROR,textField_ioErrorHandler);
  708.             textField.removeEventListener(TextEvent.TEXT_INPUT,textField_textInputHandler);
  709.             textField.removeEventListener("textFieldStyleChange",textField_textFieldStyleChangeHandler);
  710.             textField.removeEventListener("textFormatChange",textField_textFormatChangeHandler);
  711.             textField.removeEventListener("textInsert",textField_textModifiedHandler);
  712.             textField.removeEventListener("textReplace",textField_textModifiedHandler);
  713.             removeChild(DisplayObject(textField));
  714.             textField = null;
  715.          }
  716.       }
  717.       
  718.       public function set selectionEndIndex(param1:int) : void
  719.       {
  720.          _selectionEndIndex = param1;
  721.          selectionChanged = true;
  722.          invalidateProperties();
  723.       }
  724.       
  725.       public function get textHeight() : Number
  726.       {
  727.          return _textHeight;
  728.       }
  729.       
  730.       public function set editable(param1:Boolean) : void
  731.       {
  732.          if(param1 == _editable)
  733.          {
  734.             return;
  735.          }
  736.          _editable = param1;
  737.          editableChanged = true;
  738.          invalidateProperties();
  739.          dispatchEvent(new Event("editableChanged"));
  740.       }
  741.       
  742.       override protected function commitProperties() : void
  743.       {
  744.          super.commitProperties();
  745.          if(hasFontContextChanged() && textField != null)
  746.          {
  747.             removeTextField();
  748.             createTextField(-1);
  749.             accessibilityPropertiesChanged = true;
  750.             condenseWhiteChanged = true;
  751.             displayAsPasswordChanged = true;
  752.             editableChanged = true;
  753.             enabledChanged = true;
  754.             maxCharsChanged = true;
  755.             restrictChanged = true;
  756.             selectableChanged = true;
  757.             tabIndexChanged = true;
  758.             wordWrapChanged = true;
  759.             textChanged = true;
  760.             selectionChanged = true;
  761.          }
  762.          if(accessibilityPropertiesChanged)
  763.          {
  764.             textField.accessibilityProperties = _accessibilityProperties;
  765.             accessibilityPropertiesChanged = false;
  766.          }
  767.          if(condenseWhiteChanged)
  768.          {
  769.             textField.condenseWhite = _condenseWhite;
  770.             condenseWhiteChanged = false;
  771.          }
  772.          if(displayAsPasswordChanged)
  773.          {
  774.             textField.displayAsPassword = _displayAsPassword;
  775.             displayAsPasswordChanged = false;
  776.          }
  777.          if(editableChanged)
  778.          {
  779.             textField.type = _editable && enabled ? TextFieldType.INPUT : TextFieldType.DYNAMIC;
  780.             editableChanged = false;
  781.          }
  782.          if(enabledChanged)
  783.          {
  784.             textField.enabled = enabled;
  785.             enabledChanged = false;
  786.          }
  787.          if(maxCharsChanged)
  788.          {
  789.             textField.maxChars = _maxChars;
  790.             maxCharsChanged = false;
  791.          }
  792.          if(restrictChanged)
  793.          {
  794.             textField.restrict = _restrict;
  795.             restrictChanged = false;
  796.          }
  797.          if(selectableChanged)
  798.          {
  799.             textField.selectable = _selectable;
  800.             selectableChanged = false;
  801.          }
  802.          if(styleSheetChanged)
  803.          {
  804.             textField.styleSheet = _styleSheet;
  805.             styleSheetChanged = false;
  806.          }
  807.          if(tabIndexChanged)
  808.          {
  809.             textField.tabIndex = _tabIndex;
  810.             tabIndexChanged = false;
  811.          }
  812.          if(wordWrapChanged)
  813.          {
  814.             textField.wordWrap = _wordWrap;
  815.             wordWrapChanged = false;
  816.          }
  817.          if(textChanged || htmlTextChanged)
  818.          {
  819.             if(isHTML)
  820.             {
  821.                textField.htmlText = explicitHTMLText;
  822.             }
  823.             else
  824.             {
  825.                textField.text = _text;
  826.             }
  827.             textFieldChanged(false,true);
  828.             textChanged = false;
  829.             htmlTextChanged = false;
  830.          }
  831.          if(selectionChanged)
  832.          {
  833.             textField.setSelection(_selectionBeginIndex,_selectionEndIndex);
  834.             selectionChanged = false;
  835.          }
  836.          if(!isNaN(_hScrollPosition))
  837.          {
  838.             horizontalScrollPosition = _hScrollPosition;
  839.          }
  840.          if(!isNaN(_vScrollPosition))
  841.          {
  842.             verticalScrollPosition = _vScrollPosition;
  843.          }
  844.       }
  845.       
  846.       private function get isHTML() : Boolean
  847.       {
  848.          return explicitHTMLText != null;
  849.       }
  850.       
  851.       public function set listData(param1:BaseListData) : void
  852.       {
  853.          _listData = param1;
  854.       }
  855.       
  856.       [Bindable("maxCharsChanged")]
  857.       public function get maxChars() : int
  858.       {
  859.          return _maxChars;
  860.       }
  861.       
  862.       override public function get maxHorizontalScrollPosition() : Number
  863.       {
  864.          return !!textField ? Number(textField.maxScrollH) : Number(0);
  865.       }
  866.       
  867.       override protected function mouseWheelHandler(param1:MouseEvent) : void
  868.       {
  869.          param1.stopPropagation();
  870.       }
  871.       
  872.       private function textField_scrollHandler(param1:Event) : void
  873.       {
  874.          var _loc2_:int = 0;
  875.          var _loc3_:int = 0;
  876.          var _loc4_:ScrollEvent = null;
  877.          if(initialized && allowScrollEvent)
  878.          {
  879.             _loc2_ = textField.scrollH - horizontalScrollPosition;
  880.             _loc3_ = textField.scrollV - 1 - verticalScrollPosition;
  881.             horizontalScrollPosition = textField.scrollH;
  882.             verticalScrollPosition = textField.scrollV - 1;
  883.             if(_loc2_)
  884.             {
  885.                _loc4_ = new ScrollEvent(ScrollEvent.SCROLL,false,false,null,horizontalScrollPosition,ScrollEventDirection.HORIZONTAL,_loc2_);
  886.                dispatchEvent(_loc4_);
  887.             }
  888.             if(_loc3_)
  889.             {
  890.                _loc4_ = new ScrollEvent(ScrollEvent.SCROLL,false,false,null,verticalScrollPosition,ScrollEventDirection.VERTICAL,_loc3_);
  891.                dispatchEvent(_loc4_);
  892.             }
  893.          }
  894.       }
  895.       
  896.       public function set wordWrap(param1:Boolean) : void
  897.       {
  898.          if(param1 == _wordWrap)
  899.          {
  900.             return;
  901.          }
  902.          _wordWrap = param1;
  903.          wordWrapChanged = true;
  904.          invalidateProperties();
  905.          invalidateDisplayList();
  906.          dispatchEvent(new Event("wordWrapChanged"));
  907.       }
  908.       
  909.       private function textField_textModifiedHandler(param1:Event) : void
  910.       {
  911.          textFieldChanged(false,true);
  912.       }
  913.       
  914.       private function textField_textFormatChangeHandler(param1:Event) : void
  915.       {
  916.          textFieldChanged(true,false);
  917.       }
  918.       
  919.       public function set htmlText(param1:String) : void
  920.       {
  921.          textSet = true;
  922.          if(!param1)
  923.          {
  924.             param1 = "";
  925.          }
  926.          _htmlText = param1;
  927.          htmlTextChanged = true;
  928.          _text = null;
  929.          explicitHTMLText = param1;
  930.          invalidateProperties();
  931.          invalidateSize();
  932.          invalidateDisplayList();
  933.          dispatchEvent(new Event("htmlTextChanged"));
  934.       }
  935.       
  936.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  937.       {
  938.          super.updateDisplayList(param1,param2);
  939.          var _loc3_:EdgeMetrics = viewMetrics;
  940.          _loc3_.left += getStyle("paddingLeft");
  941.          _loc3_.top += getStyle("paddingTop");
  942.          _loc3_.right += getStyle("paddingRight");
  943.          _loc3_.bottom += getStyle("paddingBottom");
  944.          textField.move(_loc3_.left,_loc3_.top);
  945.          var _loc4_:Number = param1 - _loc3_.left - _loc3_.right;
  946.          var _loc5_:Number = param2 - _loc3_.top - _loc3_.bottom;
  947.          if(_loc3_.top + _loc3_.bottom > 0)
  948.          {
  949.             _loc5_++;
  950.          }
  951.          textField.setActualSize(Math.max(4,_loc4_),Math.max(4,_loc5_));
  952.          if(!initialized)
  953.          {
  954.             callLater(invalidateDisplayList);
  955.          }
  956.          else
  957.          {
  958.             callLater(adjustScrollBars);
  959.          }
  960.          if(isNaN(_hScrollPosition))
  961.          {
  962.             _hScrollPosition = 0;
  963.          }
  964.          if(isNaN(_vScrollPosition))
  965.          {
  966.             _vScrollPosition = 0;
  967.          }
  968.          var _loc6_:Number;
  969.          if((_loc6_ = Math.min(textField.maxScrollH,_hScrollPosition)) != textField.scrollH)
  970.          {
  971.             horizontalScrollPosition = _loc6_;
  972.          }
  973.          if((_loc6_ = Math.min(textField.maxScrollV - 1,_vScrollPosition)) != textField.scrollV - 1)
  974.          {
  975.             verticalScrollPosition = _loc6_;
  976.          }
  977.       }
  978.       
  979.       public function getLineMetrics(param1:int) : TextLineMetrics
  980.       {
  981.          return !!textField ? textField.getLineMetrics(param1) : null;
  982.       }
  983.       
  984.       override public function get verticalScrollPolicy() : String
  985.       {
  986.          return height <= 40 ? ScrollPolicy.OFF : mx_internal::_verticalScrollPolicy;
  987.       }
  988.       
  989.       public function get length() : int
  990.       {
  991.          return text != null ? int(text.length) : -1;
  992.       }
  993.    }
  994. }
  995.